{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 淘宝旺旺：充电时间   提醒您：\n",
    "     1. 在所有In[]里的  ### START CODE HERE ### 和  ### END CODE HERE ### 之间的位置 填写您的答案代码，(≈ 3 lines of code)括号里会提示答案大概有几行代码，当然每个人写法可能不一样\n",
    "     2. 鼠标点了当前这个In[]后，再按上面Run按钮运行代码，如果答案正确，将会得到和下面 Expected output提示一致的输出内容\n",
    "\n",
    "\n",
    "#### 切记切记：\n",
    "     1. 首次使用时，每个In[] 一定要从上往下逐个Run，否则如果直接从中间或者后面开始会出现类似变量未定义的错误提示，因为前面的代码都没运行过\n",
    "     2. 如果要移动作业位置的话，单个编程作业一定要整个文件夹拷贝，因为里面的images,datasess 等资源文件/文件夹和.ipynb作业文件是关联的，否则运行会出错\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Tutorial\n",
    "\n",
    "Welcome to this week's programming assignment. Until now, you've always used numpy to build neural networks. Now we will step you through a deep learning framework that will allow you to build neural networks more easily. Machine learning frameworks like TensorFlow, PaddlePaddle, Torch, Caffe, Keras, and many others can speed up your machine learning development significantly. All of these frameworks also have a lot of documentation, which you should feel free to read. In this assignment, you will learn to do the following in TensorFlow: \n",
    "\n",
    "- Initialize variables\n",
    "- Start your own session\n",
    "- Train algorithms \n",
    "- Implement a Neural Network\n",
    "\n",
    "Programing frameworks can not only shorten your coding time, but sometimes also perform optimizations that speed up your code. \n",
    "\n",
    "## 1 - Exploring the Tensorflow Library\n",
    "\n",
    "To start, you will import the library:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have imported the library, we will walk you through its different applications. You will start with an example, where we compute for you the loss of one training example. \n",
    "$$loss = \\mathcal{L}(\\hat{y}, y) = (\\hat y^{(i)} - y^{(i)})^2 \\tag{1}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\夏戈\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "y_hat = tf.constant(36, name='y_hat')            # Define y_hat constant. Set to 36.\n",
    "y = tf.constant(39, name='y')                    # Define y. Set to 39\n",
    "\n",
    "loss = tf.Variable((y - y_hat)**2, name='loss')  # Create a variable for the loss\n",
    "\n",
    "init = tf.global_variables_initializer()         # When init is run later (session.run(init)),\n",
    "                                                 # the loss variable will be initialized and ready to be computed\n",
    "with tf.Session() as session:                    # Create a session and print the output\n",
    "    session.run(init)                            # Initializes the variables\n",
    "    print(session.run(loss))                     # Prints the loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing and running programs in TensorFlow has the following steps:\n",
    "\n",
    "1. Create Tensors (variables) that are not yet executed/evaluated. \n",
    "2. Write operations between those Tensors.\n",
    "3. Initialize your Tensors. \n",
    "4. Create a Session. \n",
    "5. Run the Session. This will run the operations you'd written above. \n",
    "\n",
    "Therefore, when we created a variable for the loss, we simply defined the loss as a function of other quantities, but did not evaluate its value. To evaluate it, we had to run `init=tf.global_variables_initializer()`. That initialized the loss variable, and in the last line we were finally able to evaluate the value of `loss` and print its value.\n",
    "\n",
    "Now let us look at an easy example. Run the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Mul:0\", shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant(2)\n",
    "b = tf.constant(10)\n",
    "c = tf.multiply(a,b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, you will not see 20! You got a tensor saying that the result is a tensor that does not have the shape attribute(属性), and is of type \"int32\". All you did was put in the 'computation graph', but you have not run this computation yet. In order to actually multiply the two numbers, you will have to create a session and run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "print(sess.run(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! To summarize, **remember to initialize your variables, create a session and run the operations inside the session**. \n",
    "\n",
    "Next, you'll also have to know about placeholders. A placeholder is an object whose value you can specify only later. \n",
    "To specify values for a placeholder, you can pass in values by using a \"feed dictionary\" (`feed_dict` variable). Below, we created a placeholder for x. This allows us to pass in a number later when we run the session. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# Change the value of x in the feed_dict\n",
    "\n",
    "x = tf.placeholder(tf.int64, name = 'x')\n",
    "print(sess.run(2 * x, feed_dict = {x: 2}))\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you first defined `x` you did not have to specify a value for it. A placeholder is simply a variable that you will assign data to only later, when running the session. We say that you **feed data** to these placeholders when running the session. \n",
    "\n",
    "Here's what's happening: When you specify the operations needed for a computation, you are telling TensorFlow how to construct a computation graph. The computation graph can have some placeholders whose values you will specify only later. Finally, when you run the session, you are telling TensorFlow to execute the computation graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 - Linear function\n",
    "\n",
    "Lets start this programming exercise by computing the following equation: $Y = WX + b$, where $W$ and $X$ are random matrices and b is a random vector. \n",
    "\n",
    "**Exercise**: Compute $WX + b$ where $W, X$, and $b$ are drawn from a random normal distribution. W is of shape (4, 3), X is (3,1) and b is (4,1). As an example, here is how you would define a constant X that has shape (3,1):\n",
    "```python\n",
    "X = tf.constant(np.random.randn(3,1), name = \"X\")\n",
    "\n",
    "```\n",
    "You might find the following functions helpful: \n",
    "- tf.matmul(..., ...) to do a matrix multiplication\n",
    "- tf.add(..., ...) to do an addition\n",
    "- np.random.randn(...) to initialize randomly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: linear_function\n",
    "\n",
    "def linear_function():\n",
    "    \"\"\"\n",
    "    Implements a linear function: \n",
    "            Initializes W to be a random tensor of shape (4,3)\n",
    "            Initializes X to be a random tensor of shape (3,1)\n",
    "            Initializes b to be a random tensor of shape (4,1)\n",
    "    Returns: \n",
    "    result -- runs the session for Y = WX + b \n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    \n",
    "    ### START CODE HERE ### (4 lines of code)\n",
    "    X = tf.constant(np.random.randn(3,1),name='X')\n",
    "    W = tf.constant(np.random.randn(4,3),name='W')\n",
    "    b = tf.constant(np.random.randn(4,1),name='b')\n",
    "    result = tf.add(tf.matmul(W,X),b)\n",
    "\n",
    "    \n",
    "    \n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    sess = tf.Session()\n",
    "    result = sess.run(result)\n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    # close the session \n",
    "    sess.close()\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result = [[-2.15657382]\n",
      " [ 2.95891446]\n",
      " [-1.08926781]\n",
      " [-0.84538042]]\n"
     ]
    }
   ],
   "source": [
    "print( \"result = \" + str(linear_function()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** Expected Output ***: \n",
    "\n",
    "<table> \n",
    "<tr> \n",
    "<td>\n",
    "**result**\n",
    "</td>\n",
    "<td>\n",
    "[[-2.15657382]\n",
    " [ 2.95891446]\n",
    " [-1.08926781]\n",
    " [-0.84538042]]\n",
    "</td>\n",
    "</tr> \n",
    "\n",
    "</table> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 - Computing the sigmoid \n",
    "Great! You just implemented a linear function. Tensorflow offers a variety of commonly used neural network functions like `tf.sigmoid` and `tf.softmax`. For this exercise lets compute the sigmoid function of an input. \n",
    "\n",
    "You will do this exercise using a placeholder variable `x`. When running the session, you should use the feed dictionary to pass in the input `z`. In this exercise, you will have to (i) create a placeholder `x`, (ii) define the operations needed to compute the sigmoid using `tf.sigmoid`, and then (iii) run the session. \n",
    "\n",
    "** Exercise **: Implement the sigmoid function below. You should use the following: \n",
    "\n",
    "- `tf.placeholder(tf.float32, name = \"...\")`\n",
    "- `tf.sigmoid(...)`\n",
    "- `sess.run(..., feed_dict = {x: z})`\n",
    "\n",
    "\n",
    "Note that there are two typical ways to create and use sessions in tensorflow: \n",
    "\n",
    "**Method 1:**\n",
    "```python\n",
    "sess = tf.Session()\n",
    "# Run the variables initialization (if needed), run the operations\n",
    "result = sess.run(..., feed_dict = {...})\n",
    "sess.close() # Close the session\n",
    "```\n",
    "**Method 2:**\n",
    "```python\n",
    "with tf.Session() as sess: \n",
    "    # run the variables initialization (if needed), run the operations\n",
    "    result = sess.run(..., feed_dict = {...})\n",
    "    # This takes care of closing the session for you :)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Computes the sigmoid of z\n",
    "    \n",
    "    Arguments:\n",
    "    z -- input value, scalar or vector\n",
    "    \n",
    "    Returns: \n",
    "    results -- the sigmoid of z\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### ( approx. 4 lines of code)\n",
    "    # Create a placeholder for x. Name it 'x'.\n",
    "    x = tf.placeholder(tf.float32,name='x')\n",
    "    \n",
    "    # compute sigmoid(x)\n",
    "    sigmoid = tf.sigmoid(x)\n",
    "    \n",
    "    # Create a session, and run it. Please use the method 2 explained above. \n",
    "    # You should use a feed_dict to pass z's value to x. \n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Run session and call the output \"result\"\n",
    "        result = sess.run(sigmoid,feed_dict={x:z})\n",
    "        \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(0) = 0.5\n",
      "sigmoid(12) = 0.9999938\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print (\"sigmoid(12) = \" + str(sigmoid(12)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** Expected Output ***: \n",
    "\n",
    "<table> \n",
    "<tr> \n",
    "<td>\n",
    "**sigmoid(0)**\n",
    "</td>\n",
    "<td>\n",
    "0.5\n",
    "</td>\n",
    "</tr>\n",
    "<tr> \n",
    "<td>\n",
    "**sigmoid(12)**\n",
    "</td>\n",
    "<td>\n",
    "0.999994\n",
    "</td>\n",
    "</tr> \n",
    "\n",
    "</table> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**To summarize, you how know how to**:\n",
    "1. Create placeholders\n",
    "2. Specify the computation graph corresponding to operations you want to compute\n",
    "3. Create the session\n",
    "4. Run the session, using a feed dictionary if necessary to specify placeholder variables' values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 -  Computing the Cost\n",
    "\n",
    "You can also use a built-in function to compute the cost of your neural network. So instead of needing to write code to compute this as a function of $a^{[2](i)}$ and $y^{(i)}$ for i=1...m: \n",
    "$$ J = - \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log a^{ [2] (i)} + (1-y^{(i)})\\log (1-a^{ [2] (i)} )\\large )\\small\\tag{2}$$\n",
    "\n",
    "you can do it in one line of code in tensorflow!\n",
    "\n",
    "**Exercise**: Implement the cross entropy loss. The function you will use is: \n",
    "\n",
    "\n",
    "- `tf.nn.sigmoid_cross_entropy_with_logits(logits = ...,  labels = ...)`\n",
    "\n",
    "Your code should input `z`, compute the sigmoid (to get `a`) and then compute the cross entropy cost $J$. All this can be done using one call to `tf.nn.sigmoid_cross_entropy_with_logits`, which computes\n",
    "\n",
    "$$- \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log \\sigma(z^{[2](i)}) + (1-y^{(i)})\\log (1-\\sigma(z^{[2](i)})\\large )\\small\\tag{2}$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: cost\n",
    "\n",
    "def cost(logits, labels):\n",
    "    \"\"\"\n",
    "    Computes the cost using the sigmoid cross entropy\n",
    "    \n",
    "    Arguments:\n",
    "    logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)\n",
    "    labels -- vector of labels y (1 or 0) \n",
    "    \n",
    "    Note: What we've been calling \"z\" and \"y\" in this class are respectively called \"logits\" and \"labels\" \n",
    "    in the TensorFlow documentation. So logits will feed into z, and labels into y. \n",
    "    \n",
    "    Returns:\n",
    "    cost -- runs the session of the cost (formula (2))\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### \n",
    "    \n",
    "    # Create the placeholders for \"logits\" (z) and \"labels\" (y) (approx. 2 lines)\n",
    "    z = tf.placeholder(tf.float32,name='z')\n",
    "    y = tf.placeholder(tf.float32,name='y')\n",
    "    \n",
    "    \n",
    "    # Use the loss function (approx. 1 line)\n",
    "    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z,labels=y)\n",
    "    \n",
    "    # Create a session (approx. 1 line). See method 1 above.\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line).\n",
    "    cost = sess.run(cost,feed_dict={z:logits,y:labels})\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "\n",
    "    sess.close()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost = [1.0053872  1.0366408  0.41385433 0.39956617]\n"
     ]
    }
   ],
   "source": [
    "logits = sigmoid(np.array([0.2,0.4,0.7,0.9]))\n",
    "cost = cost(logits, np.array([0,0,1,1]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Expected Output** : \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **cost**\n",
    "        </td>\n",
    "        <td>\n",
    "        [ 1.00538719  1.03664088  0.41385433  0.39956614]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 - Using One Hot encodings\n",
    "\n",
    "Many times in deep learning you will have a y vector with numbers ranging from 0 to C-1, where C is the number of classes. If C is for example 4, then you might have the following y vector which you will need to convert as follows:\n",
    "\n",
    "\n",
    "<img src=\"images/onehot.png\" style=\"width:600px;height:150px;\">\n",
    "\n",
    "This is called a \"one hot\" encoding, because in the converted representation exactly one element of each column is \"hot\" (meaning set to 1). To do this conversion in numpy, you might have to write a few lines of code. In tensorflow, you can use one line of code: \n",
    "\n",
    "- tf.one_hot(labels, depth, axis) \n",
    "\n",
    "**Exercise:** Implement the function below to take one vector of labels and the total number of classes $C$, and return the one hot encoding. Use `tf.one_hot()` to do this. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: one_hot_matrix\n",
    "\n",
    "def one_hot_matrix(labels, C):\n",
    "    \"\"\"\n",
    "    Creates a matrix where the i-th row corresponds to the ith class number and the jth column\n",
    "                     corresponds to the jth training example. So if example j had a label i. Then entry (i,j) \n",
    "                     will be 1. \n",
    "                     \n",
    "    Arguments:\n",
    "    labels -- vector containing the labels \n",
    "    C -- number of classes, the depth of the one hot dimension\n",
    "    \n",
    "    Returns: \n",
    "    one_hot -- one hot matrix\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Create a tf.constant equal to C (depth), name it 'C'. (approx. 1 line)\n",
    "    C = tf.constant(value=C,name='C')\n",
    "    \n",
    "    # Use tf.one_hot, be careful with the axis (approx. 1 line)\n",
    "    one_hot_matrix = tf.one_hot(labels,C,axis=0)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line)\n",
    "    one_hot = sess.run(one_hot_matrix)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one_hot = [[0. 0. 0. 1. 0. 0.]\n",
      " [1. 0. 0. 0. 0. 1.]\n",
      " [0. 1. 0. 0. 1. 0.]\n",
      " [0. 0. 1. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "labels = np.array([1,2,3,0,2,1])\n",
    "one_hot = one_hot_matrix(labels, C = 4)\n",
    "print (\"one_hot = \" + str(one_hot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **one_hot**\n",
    "        </td>\n",
    "        <td>\n",
    "        [[ 0.  0.  0.  1.  0.  0.]\n",
    " [ 1.  0.  0.  0.  0.  1.]\n",
    " [ 0.  1.  0.  0.  1.  0.]\n",
    " [ 0.  0.  1.  0.  0.  0.]]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 - Initialize with zeros and ones\n",
    "\n",
    "Now you will learn how to initialize a vector of zeros and ones. The function you will be calling is `tf.ones()`. To initialize with zeros you could use tf.zeros() instead. These functions take in a shape and return an array of dimension shape full of zeros and ones respectively. \n",
    "\n",
    "**Exercise:** Implement the function below to take in a shape and to return an array (of the shape's dimension of ones). \n",
    "\n",
    " - tf.ones(shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: ones\n",
    "\n",
    "def ones(shape):\n",
    "    \"\"\"\n",
    "    Creates an array of ones of dimension shape\n",
    "    \n",
    "    Arguments:\n",
    "    shape -- shape of the array you want to create\n",
    "        \n",
    "    Returns: \n",
    "    ones -- array containing only ones\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Create \"ones\" tensor using tf.ones(...). (approx. 1 line)\n",
    "    ones = tf.ones(shape)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session to compute 'ones' (approx. 1 line)\n",
    "    ones = sess.run(ones)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    return ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ones = [1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print (\"ones = \" + str(ones([3])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **ones**\n",
    "        </td>\n",
    "        <td>\n",
    "        [ 1.  1.  1.]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - Building your first neural network in tensorflow\n",
    "\n",
    "In this part of the assignment you will build a neural network using tensorflow. Remember that there are two parts to implement a tensorflow model:\n",
    "\n",
    "- Create the computation graph\n",
    "- Run the graph\n",
    "\n",
    "Let's delve into the problem you'd like to solve!\n",
    "\n",
    "### 2.0 - Problem statement: SIGNS Dataset\n",
    "\n",
    "One afternoon, with some friends we decided to teach our computers to decipher sign language. We spent a few hours taking pictures in front of a white wall and came up with the following dataset. It's now your job to build an algorithm that would facilitate communications from a speech-impaired person to someone who doesn't understand sign language.\n",
    "\n",
    "- **Training set**: 1080 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (180 pictures per number).\n",
    "- **Test set**: 120 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (20 pictures per number).\n",
    "\n",
    "Note that this is a subset of the SIGNS dataset. The complete dataset contains many more signs.\n",
    "\n",
    "Here are examples for each number, and how an explanation of how we represent the labels. These are the original pictures, before we lowered the image resolutoion to 64 by 64 pixels.\n",
    "<img src=\"images/hands.png\" style=\"width:800px;height:350px;\"><caption><center> <u><font color='purple'> **Figure 1**</u><font color='purple'>: SIGNS dataset <br> <font color='black'> </center>\n",
    "\n",
    "\n",
    "Run the following code to load the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the dataset\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change the index below and run the cell to visualize some examples in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 0\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual you flatten the image dataset, then normalize it by dividing by 255. On top of that, you will convert each label to a one-hot vector as shown in Figure 1. Run the cell below to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (12288, 1080)\n",
      "Y_train shape: (6, 1080)\n",
      "X_test shape: (12288, 120)\n",
      "Y_test shape: (6, 120)\n"
     ]
    }
   ],
   "source": [
    "# Flatten the training and test images\n",
    "X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0], -1).T\n",
    "X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T\n",
    "# Normalize image vectors\n",
    "X_train = X_train_flatten/255.\n",
    "X_test = X_test_flatten/255.\n",
    "# Convert training and test labels to one hot matrices\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6)\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6)\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[1]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[1]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** that 12288 comes from $64 \\times 64 \\times 3$. Each image is square, 64 by 64 pixels, and 3 is for the RGB colors. Please make sure all these shapes make sense to you before continuing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your goal** is to build an algorithm capable of recognizing a sign with high accuracy. To do so, you are going to build a tensorflow model that is almost the same as one you have previously built in numpy for cat recognition (but now using a softmax output). It is a great occasion to compare your numpy implementation to the tensorflow one. \n",
    "\n",
    "**The model** is *LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX*. The SIGMOID output layer has been converted to a SOFTMAX. A SOFTMAX layer generalizes SIGMOID to when there are more than two classes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 - Create placeholders\n",
    "\n",
    "Your first task is to create placeholders for `X` and `Y`. This will allow you to later pass your training data in when you run your session. \n",
    "\n",
    "**Exercise:** Implement the function below to create the placeholders in tensorflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: create_placeholders\n",
    "\n",
    "def create_placeholders(n_x, n_y):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    n_x -- scalar, size of an image vector (num_px * num_px = 64 * 64 * 3 = 12288)\n",
    "    n_y -- scalar, number of classes (from 0 to 5, so -> 6)\n",
    "    \n",
    "    Returns:\n",
    "    X -- placeholder for the data input, of shape [n_x, None] and dtype \"float\"\n",
    "    Y -- placeholder for the input labels, of shape [n_y, None] and dtype \"float\"\n",
    "    \n",
    "    Tips:\n",
    "    - You will use None because it let's us be flexible on the number of examples you will for the placeholders.\n",
    "      In fact, the number of examples during test/train is different.\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (approx. 2 lines)\n",
    "    X = tf.placeholder(tf.float32,shape=[n_x,None])\n",
    "    Y = tf.placeholder(tf.float32,shape=[n_y,None])\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = Tensor(\"Placeholder:0\", shape=(12288, ?), dtype=float32)\n",
      "Y = Tensor(\"Placeholder_1:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "X, Y = create_placeholders(12288, 6)\n",
    "print (\"X = \" + str(X))\n",
    "print (\"Y = \" + str(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **X**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Placeholder_1:0\", shape=(12288, ?), dtype=float32) (not necessarily Placeholder_1)\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **Y**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Placeholder_2:0\", shape=(10, ?), dtype=float32) (not necessarily Placeholder_2)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 - Initializing the parameters\n",
    "\n",
    "Your second task is to initialize the parameters in tensorflow.\n",
    "\n",
    "**Exercise:** Implement the function below to initialize the parameters in tensorflow. You are going use Xavier Initialization for weights and Zero Initialization for biases. The shapes are given below. As an example, to help you, for W1 and b1 you could use: \n",
    "\n",
    "```python\n",
    "W1 = tf.get_variable(\"W1\", [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "b1 = tf.get_variable(\"b1\", [25,1], initializer = tf.zeros_initializer())\n",
    "```\n",
    "Please use `seed = 1` to make sure your results match ours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_parameters\n",
    "\n",
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [25, 12288]\n",
    "                        b1 : [25, 1]\n",
    "                        W2 : [12, 25]\n",
    "                        b2 : [12, 1]\n",
    "                        W3 : [6, 12]\n",
    "                        b3 : [6, 1]\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, b1, W2, b2, W3, b3\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)                   # so that your \"random\" numbers match ours\n",
    "        \n",
    "    ### START CODE HERE ### (approx. 6 lines of code)\n",
    "    W1 = tf.get_variable('W1',[25,12288],initializer = tf.contrib.layers.xavier_initializer(seed =1))\n",
    "    b1 = tf.get_variable('b1',[25,1],initializer=tf.zeros_initializer())\n",
    "    W2 = tf.get_variable('W2',[12,25],initializer=tf.contrib.layers.xavier_initializer(seed=1))\n",
    "    b2 = tf.get_variable('b2',[12,1],initializer=tf.zeros_initializer())\n",
    "    W3 = tf.get_variable('W3',[6,12],initializer=tf.contrib.layers.xavier_initializer(seed=1))\n",
    "    b3 = tf.get_variable('b3',[6,1],initializer=tf.zeros_initializer())\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W1 = <tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref>\n",
      "b1 = <tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref>\n",
      "W2 = <tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref>\n",
      "b2 = <tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    parameters = initialize_parameters()\n",
    "    print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "    print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "    print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "    print(\"b2 = \" + str(parameters[\"b2\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **W1**\n",
    "        </td>\n",
    "        <td>\n",
    "         < tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **b1**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **W2**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **b2**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the parameters haven't been evaluated yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 - Forward propagation in tensorflow \n",
    "\n",
    "You will now implement the forward propagation module in tensorflow. The function will take in a dictionary of parameters and it will complete the forward pass. The functions you will be using are: \n",
    "\n",
    "- `tf.add(...,...)` to do an addition\n",
    "- `tf.matmul(...,...)` to do a matrix multiplication\n",
    "- `tf.nn.relu(...)` to apply the ReLU activation\n",
    "\n",
    "**Question:** Implement the forward pass of the neural network. We commented for you the numpy equivalents so that you can compare the tensorflow implementation to numpy. It is important to note that the forward propagation stops at `z3`. The reason is that in tensorflow the last linear layer output is given as input to the function computing the loss. Therefore, you don't need `a3`!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: forward_propagation\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Z3 -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "    ### START CODE HERE ### (approx. 5 lines)              # Numpy Equivalents:\n",
    "    Z1 = tf.add(tf.matmul(W1,X),b1)\n",
    "    A1 = tf.nn.relu(Z1)\n",
    "    Z2 = tf.add(tf.matmul(W2,A1),b2)\n",
    "    A2 = tf.nn.relu(Z2)\n",
    "    Z3 = tf.add(tf.matmul(W3,A2),b3)\n",
    "\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z3 = Tensor(\"Add_2:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    print(\"Z3 = \" + str(Z3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **Z3**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Add_2:0\", shape=(6, ?), dtype=float32)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed that the forward propagation doesn't output any cache. You will understand why below, when we get to brackpropagation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Compute cost\n",
    "\n",
    "As seen before, it is very easy to compute the cost using:\n",
    "```python\n",
    "tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = ..., labels = ...))\n",
    "```\n",
    "**Question**: Implement the cost function below. \n",
    "- It is important to know that the \"`logits`\" and \"`labels`\" inputs of `tf.nn.softmax_cross_entropy_with_logits` are expected to be of shape (number of examples, num_classes). We have thus transposed Z3 and Y for you.\n",
    "- Besides, `tf.reduce_mean` basically does the summation over the examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: compute_cost \n",
    "\n",
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\n",
    "    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
    "    Y -- \"true\" labels vector placeholder, same shape as Z3\n",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "    \n",
    "    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    \n",
    "    ### START CODE HERE ### (1 line of code)\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=labels))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-25-4283e06da5d5>:20: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "cost = Tensor(\"Mean:0\", shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **cost**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Mean:0\", shape=(), dtype=float32)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 - Backward propagation & parameter updates\n",
    "\n",
    "This is where you become grateful to programming frameworks. All the backpropagation and the parameters update is taken care of in 1 line of code. It is very easy to incorporate this line in the model.\n",
    "\n",
    "After you compute the cost function. You will create an \"`optimizer`\" object. You have to call this object along with the cost when running the tf.session. When called, it will perform an optimization on the given cost with the chosen method and learning rate.\n",
    "\n",
    "For instance, for gradient descent the optimizer would be:\n",
    "```python\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "```\n",
    "\n",
    "To make the optimization you would do:\n",
    "```python\n",
    "_ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "```\n",
    "\n",
    "This computes the backpropagation by passing through the tensorflow graph in the reverse order. From cost to inputs.\n",
    "\n",
    "**Note** When coding, we often use `_` as a \"throwaway\" variable to store values that we won't need to use later. Here, `_` takes on the evaluated value of `optimizer`, which we don't need (and `c` takes the value of the `cost` variable). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 - Building the model\n",
    "\n",
    "Now, you will bring it all together! \n",
    "\n",
    "**Exercise:** Implement the model. You will be calling the functions you had previously implemented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,\n",
    "          num_epochs = 1500, minibatch_size = 32, print_cost = True):\n",
    "    \"\"\"\n",
    "    Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)\n",
    "    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)\n",
    "    X_test -- training set, of shape (input size = 12288, number of training examples = 120)\n",
    "    Y_test -- test set, of shape (output size = 6, number of test examples = 120)\n",
    "    learning_rate -- learning rate of the optimization\n",
    "    num_epochs -- number of epochs of the optimization loop\n",
    "    minibatch_size -- size of a minibatch\n",
    "    print_cost -- True to print the cost every 100 epochs\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "    \"\"\"\n",
    "    \n",
    "    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "    tf.set_random_seed(1)                             # to keep consistent results\n",
    "    seed = 3                                          # to keep consistent results\n",
    "    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)\n",
    "    n_y = Y_train.shape[0]                            # n_y : output size\n",
    "    costs = []                                        # To keep track of the cost\n",
    "    \n",
    "    # Create Placeholders of shape (n_x, n_y)\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    X,Y=create_placeholders(n_x,n_y)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Initialize parameters\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    parameters = initialize_parameters()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    Z3 = forward_propagation(X,parameters)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    cost = compute_cost(Z3,Y)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Initialize all the variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # Start the session to compute the tensorflow graph\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Run the initialization\n",
    "        sess.run(init)\n",
    "        \n",
    "        # Do the training loop\n",
    "        for epoch in range(num_epochs):\n",
    "\n",
    "            epoch_cost = 0.                       # Defines a cost related to an epoch\n",
    "            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "            seed = seed + 1\n",
    "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "            for minibatch in minibatches:\n",
    "\n",
    "                # Select a minibatch\n",
    "                (minibatch_X, minibatch_Y) = minibatch\n",
    "                \n",
    "                # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                # Run the session to execute the \"optimizer\" and the \"cost\", the feedict should contain a minibatch for (X,Y).\n",
    "                ### START CODE HERE ### (1 line)\n",
    "                _,minibatch_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})\n",
    "                ### END CODE HERE ###\n",
    "                \n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost == True and epoch % 100 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                costs.append(epoch_cost)\n",
    "                \n",
    "        # plot the cost\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "        # lets save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print (\"Parameters have been trained!\")\n",
    "\n",
    "        # Calculate the correct predictions\n",
    "        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))\n",
    "\n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "        print (\"Train Accuracy:\", accuracy.eval({X: X_train, Y: Y_train}))\n",
    "        print (\"Test Accuracy:\", accuracy.eval({X: X_test, Y: Y_test}))\n",
    "        \n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Run the following cell to train your model! On our machine it takes about 5 minutes. Your \"Cost after epoch 100\" should be 1.016458. If it's not, don't waste time; interrupt the training by clicking on the square (⬛) in the upper bar of the notebook, and try to correct your code. If it is the correct cost, take a break and come back in 5 minutes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.855702\n",
      "Cost after epoch 100: 1.017255\n",
      "Cost after epoch 200: 0.733184\n",
      "Cost after epoch 300: 0.573071\n",
      "Cost after epoch 400: 0.468573\n",
      "Cost after epoch 500: 0.381228\n",
      "Cost after epoch 600: 0.313815\n",
      "Cost after epoch 700: 0.253708\n",
      "Cost after epoch 800: 0.203900\n",
      "Cost after epoch 900: 0.166454\n",
      "Cost after epoch 1000: 0.146636\n",
      "Cost after epoch 1100: 0.107279\n",
      "Cost after epoch 1200: 0.086698\n",
      "Cost after epoch 1300: 0.059342\n",
      "Cost after epoch 1400: 0.052289\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "Train Accuracy: 0.9990741\n",
      "Test Accuracy: 0.725\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **Train Accuracy**\n",
    "        </td>\n",
    "        <td>\n",
    "        0.999074\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **Test Accuracy**\n",
    "        </td>\n",
    "        <td>\n",
    "        0.716667\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>\n",
    "\n",
    "Amazing, your algorithm can recognize a sign representing a figure between 0 and 5 with 71.7% accuracy.\n",
    "\n",
    "**Insights**:\n",
    "- Your model seems big enough to fit the training set well. However, given the difference between train and test accuracy, you could try to add L2 or dropout regularization to reduce overfitting. \n",
    "- Think about the session as a block of code to train the model. Each time you run the session on a minibatch, it trains the parameters. In total you have run the session a large number of times (1500 epochs) until you obtained well trained parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 - Test with your own image (optional / ungraded exercise)\n",
    "\n",
    "Congratulations on finishing this assignment. You can now take a picture of your hand and see the output of your model. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Write your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:11: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  # This is added back by InteractiveShellApp.init_path()\n",
      "D:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:12: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n",
      "  if sys.path[0] == '':\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your algorithm predicts: y = 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = 'thumbs_up.jpg'\n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess your image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T\n",
    "my_image_prediction = predict(my_image, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"Your algorithm predicts: y = \" + str(np.squeeze(my_image_prediction)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You indeed deserved a \"thumbs-up\" although as you can see the algorithm seems to classify it incorrectly. The reason is that the training set doesn't contain any \"thumbs-up\", so the model doesn't know how to deal with it! We call that a \"mismatched data distribution\" and it is one of the various of the next course on \"Structuring Machine Learning Projects\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<font color='blue'>\n",
    "**What you should remember**:\n",
    "- Tensorflow is a programming framework used in deep learning\n",
    "- The two main object classes in tensorflow are Tensors and Operators. \n",
    "- When you code in tensorflow you have to take the following steps:\n",
    "    - Create a graph containing Tensors (Variables, Placeholders ...) and Operations (tf.matmul, tf.add, ...)\n",
    "    - Create a session\n",
    "    - Initialize the session\n",
    "    - Run the session to execute the graph\n",
    "- You can execute the graph multiple times as you've seen in model()\n",
    "- The backpropagation and optimization is automatically done when running the session on the \"optimizer\" object."
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "deep-neural-network",
   "graded_item_id": "BFd89",
   "launcher_item_id": "AH2rK"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
